Developer CD Series 1996 May: Tool Chest/Developer CD Series May 1996 (Tool Chest) (Apple Computer) (1996).iso/Sample Code/Http Server/•OT_Classes/TNetworkStream.cp

Text File | 1996-01-11 | 6.2 KB | 251 lines | [TEXT/CWIE]

//    TNetworkStream.cp - Macintosh OpenTransport Network Stream IO class object
//
// Apple Macintosh Developer Technical Support
// Written by:  Vinne Moscaritolo
//
//  Copyright (work in progress)  Apple Computer, Inc All rights reserved.
//
// You may incorporate this sample code into your applications without
// restriction, though the sample code has been provided "AS IS" and the
// responsibility for its operation is 100% yours.  However, what you are
// not permitted to do is to redistribute the source as "DSC Sample Code"
// after having made changes. If you're going to re-distribute the source,
// we require that you make it clear in the source that the code was
// descended from Apple Sample Code, but that you've made changes.
//

#include "TNetworkStream.h"
#include <iomanip.h>

#define DEFAULT_CHUNKSIZE 512


// ---------------------------------------------------------------------------
// --------------------------- Network Output Stream -------------------------
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
//     ~TNetworkIOStream()
// ---------------------------------------------------------------------------
//    Destructor
TNetworkIOStream::~TNetworkIOStream()
{
}


// ---------------------------------------------------------------------------
// --------------------------- Network Stream Buffer -------------------------
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
//     ~TNetworkBuf
// ---------------------------------------------------------------------------
//    Destructor

TNetworkBuf::~TNetworkBuf()
{
    close();
};


// ---------------------------------------------------------------------------
//     attach(ep)
// ---------------------------------------------------------------------------
//    attach Network stream to endpoint

void TNetworkBuf::attach(EndpointRef ep, TEndpointInfo* info)
{

// insure that it isn't open already
    if (is_open()) return;

// OK to set up
    fEndPoint = ep;
    fInfo =     info;

// calculate optimal chunk size
    fChunkSize = (fInfo->tsdu < 1) ? DEFAULT_CHUNKSIZE :fInfo->tsdu;
}


// ---------------------------------------------------------------------------
//     close()
// ---------------------------------------------------------------------------
//    close network stream

void  TNetworkBuf::close()
{
    if (is_open())  {
// blow ya load
        if(fBuffer)    sync();

// clean up after
        fEndPoint = kOTInvalidRef;
        fBuffer = nil;
        setp(0, 0);

// initiate teardown here???
    }
}


// ---------------------------------------------------------------------------
//     sync()
// ---------------------------------------------------------------------------
//    sync buffer

int TNetworkBuf::sync()
{
// can only output when open.
    if (! is_open()) return EOF;

// flush buffers
    flush_output();

    return 0;
}


// ---------------------------------------------------------------------------
//     overflow(c)
// ---------------------------------------------------------------------------
//    process chars in bufffer area

int TNetworkBuf::overflow(int c)
{
// allocate buffer space if needed
    if(pbase() == 0 && !doallocate())  return EOF;

// if flush requested force output
    if(c == EOF) return flush_output();

// check if we are at end of buffer
    if ((pptr() >= epptr()) && flush_output(T_MORE) && !doallocate()) return EOF;

// store char
    *pptr() = c; pbump(1);

    return c;
}

// ---------------------------------------------------------------------------
//     doallocate()
// ---------------------------------------------------------------------------
//    return true if alocation

Boolean TNetworkBuf::doallocate()
{
    if(!pbase() && (fBuffer = (char*) ::OTAllocMem(fChunkSize) )) {
        setp(fBuffer, fBuffer + fChunkSize );
        return true;
        }
    return  false;
}

// ---------------------------------------------------------------------------
//     xputn(char*, len)
// ---------------------------------------------------------------------------
//    stuff chars into output buffer

int TNetworkBuf::xsputn( const char *s, int len)
{
    const unsigned char *p = (const unsigned char*) s;

    if(len <= 0) return 0;

    for(int i = 0; i<len; i++, p++)
        if( sputc(*p) == EOF ) return i;

    return len;
}


// ---------------------------------------------------------------------------
//     flush_output()
// ---------------------------------------------------------------------------
//    flush output buffer

int TNetworkBuf::flush_output(OTFlags flags)
{
    int len = fBuffer ? pptr() - pbase(): 0;

// can only output when open.
    if (! is_open()) return EOF;

// out any data
    if (len || (fInfo->flags & T_SENDZERO) ) {
        ::OTSnd(fEndPoint, fBuffer, len , flags);
        fBuffer = nil;
        setp(0,0);
        }

    return len;
}



// ---------------------------------------------------------------------------
//     underflow()
// ---------------------------------------------------------------------------
//    flush output buffer

int TNetworkBuf::underflow()
{
    return EOF;
}


// ---------------------------------------------------------------------------
//     uflow()
// ---------------------------------------------------------------------------
//

int TNetworkBuf::uflow()
{
    return EOF;
}


// ---------------------------------------------------------------------------
//     Release(buf);
// ---------------------------------------------------------------------------
//    Release buffer chain

void TNetworkBuf::Release(void* buf)
{
    ::OTFreeMem( buf );
}



// ---------------------------------------------------------------------------
//     buf = ReserveBuffer(req, resp );
// ---------------------------------------------------------------------------
//
////// WRITE ME

char* TNetworkBuf::ReserveBuffer(size_t  reqCount, size_t  *actCount )
{

    *actCount  =  (reqCount > BUFFSIZE) ? BUFFSIZE : reqCount ;
    return ( (char*) Buffer );
}



// ---------------------------------------------------------------------------
//     EnqueueBuffer(buf, size );
// ---------------------------------------------------------------------------
//
////// WRITE ME

void  TNetworkBuf::EnqueueBuffer(char* buf, size_t count )
{

    if(buf) if( count);
}